|
|||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||
ByteCollection.add(byte) instead
CharCollection.add(char) instead
DoubleCollection.add(double) instead
FloatCollection.add(float) instead
IntCollection.add(int) instead
LongCollection.add(long) instead
ShortCollection.add(short) instead
Object keys and
byte values.Map specialization with byte keys
and byte values.Object keys and
byte values.Map specialization with byte keys
and char values.bytes.Object keys and
byte values.Map specialization with byte keys
and double values.Object keys and
byte values.Map specialization with byte keys
and float values.Object keys and
byte values.Map specialization with byte keys
and int values.Object keys and
byte values.Map specialization with byte keys
and long values.Object keys and
byte values.Map specialization with byte keys
and Object values.Object keys and
byte values.Map specialization with byte keys
and short values.Object keys and
char values.Map specialization with char keys
and byte values.Object keys and
char values.Map specialization with char keys
and char values.chars.Object keys and
char values.Map specialization with char keys
and double values.Object keys and
char values.Map specialization with char keys
and float values.Object keys and
char values.Map specialization with char keys
and int values.Object keys and
char values.Map specialization with char keys
and long values.Object keys and
char values.Map specialization with char keys
and Object values.Object keys and
char values.Map specialization with char keys
and short values.ByteByteMap.compute(byte, ByteByteToByteFunction) instead
defaultValue() if there is no current mapping).
ByteCharMap.compute(byte, ByteCharToCharFunction) instead
defaultValue() if there is no current mapping).
ByteDoubleMap.compute(byte, ByteDoubleToDoubleFunction) instead
defaultValue() if there is no current mapping).
ByteFloatMap.compute(byte, ByteFloatToFloatFunction) instead
defaultValue() if there is no current mapping).
ByteIntMap.compute(byte, ByteIntToIntFunction) instead
defaultValue() if there is no current mapping).
ByteLongMap.compute(byte, ByteLongToLongFunction) instead
defaultValue() if there is no current mapping).
ByteObjMap.compute(byte, ByteObjFunction) instead
null if there is no current mapping).
ByteShortMap.compute(byte, ByteShortToShortFunction) instead
defaultValue() if there is no current mapping).
CharByteMap.compute(char, CharByteToByteFunction) instead
defaultValue() if there is no current mapping).
CharCharMap.compute(char, CharCharToCharFunction) instead
defaultValue() if there is no current mapping).
CharDoubleMap.compute(char, CharDoubleToDoubleFunction) instead
defaultValue() if there is no current mapping).
CharFloatMap.compute(char, CharFloatToFloatFunction) instead
defaultValue() if there is no current mapping).
CharIntMap.compute(char, CharIntToIntFunction) instead
defaultValue() if there is no current mapping).
CharLongMap.compute(char, CharLongToLongFunction) instead
defaultValue() if there is no current mapping).
CharObjMap.compute(char, CharObjFunction) instead
null if there is no current mapping).
CharShortMap.compute(char, CharShortToShortFunction) instead
defaultValue() if there is no current mapping).
DoubleByteMap.compute(double, DoubleByteToByteFunction) instead
defaultValue() if there is no current mapping).
DoubleCharMap.compute(double, DoubleCharToCharFunction) instead
defaultValue() if there is no current mapping).
DoubleDoubleMap.compute(double, DoubleDoubleToDoubleFunction) instead
defaultValue() if there is no current mapping).
DoubleFloatMap.compute(double, DoubleFloatToFloatFunction) instead
defaultValue() if there is no current mapping).
DoubleIntMap.compute(double, DoubleIntToIntFunction) instead
defaultValue() if there is no current mapping).
DoubleLongMap.compute(double, DoubleLongToLongFunction) instead
defaultValue() if there is no current mapping).
DoubleObjMap.compute(double, DoubleObjFunction) instead
null if there is no current mapping).
DoubleShortMap.compute(double, DoubleShortToShortFunction) instead
defaultValue() if there is no current mapping).
FloatByteMap.compute(float, FloatByteToByteFunction) instead
defaultValue() if there is no current mapping).
FloatCharMap.compute(float, FloatCharToCharFunction) instead
defaultValue() if there is no current mapping).
FloatDoubleMap.compute(float, FloatDoubleToDoubleFunction) instead
defaultValue() if there is no current mapping).
FloatFloatMap.compute(float, FloatFloatToFloatFunction) instead
defaultValue() if there is no current mapping).
FloatIntMap.compute(float, FloatIntToIntFunction) instead
defaultValue() if there is no current mapping).
FloatLongMap.compute(float, FloatLongToLongFunction) instead
defaultValue() if there is no current mapping).
FloatObjMap.compute(float, FloatObjFunction) instead
null if there is no current mapping).
FloatShortMap.compute(float, FloatShortToShortFunction) instead
defaultValue() if there is no current mapping).
IntByteMap.compute(int, IntByteToByteFunction) instead
defaultValue() if there is no current mapping).
IntCharMap.compute(int, IntCharToCharFunction) instead
defaultValue() if there is no current mapping).
IntDoubleMap.compute(int, IntDoubleToDoubleFunction) instead
defaultValue() if there is no current mapping).
IntFloatMap.compute(int, IntFloatToFloatFunction) instead
defaultValue() if there is no current mapping).
IntIntMap.compute(int, IntIntToIntFunction) instead
defaultValue() if there is no current mapping).
IntLongMap.compute(int, IntLongToLongFunction) instead
defaultValue() if there is no current mapping).
IntObjMap.compute(int, IntObjFunction) instead
null if there is no current mapping).
IntShortMap.compute(int, IntShortToShortFunction) instead
defaultValue() if there is no current mapping).
LongByteMap.compute(long, LongByteToByteFunction) instead
defaultValue() if there is no current mapping).
LongCharMap.compute(long, LongCharToCharFunction) instead
defaultValue() if there is no current mapping).
LongDoubleMap.compute(long, LongDoubleToDoubleFunction) instead
defaultValue() if there is no current mapping).
LongFloatMap.compute(long, LongFloatToFloatFunction) instead
defaultValue() if there is no current mapping).
LongIntMap.compute(long, LongIntToIntFunction) instead
defaultValue() if there is no current mapping).
LongLongMap.compute(long, LongLongToLongFunction) instead
defaultValue() if there is no current mapping).
LongObjMap.compute(long, LongObjFunction) instead
null if there is no current mapping).
LongShortMap.compute(long, LongShortToShortFunction) instead
defaultValue() if there is no current mapping).
ObjByteMap.compute(Object, ObjByteToByteFunction) instead
defaultValue() if there is no current mapping).
ObjCharMap.compute(Object, ObjCharToCharFunction) instead
defaultValue() if there is no current mapping).
ObjDoubleMap.compute(Object, ObjDoubleToDoubleFunction) instead
defaultValue() if there is no current mapping).
ObjFloatMap.compute(Object, ObjFloatToFloatFunction) instead
defaultValue() if there is no current mapping).
ObjIntMap.compute(Object, ObjIntToIntFunction) instead
defaultValue() if there is no current mapping).
ObjLongMap.compute(Object, ObjLongToLongFunction) instead
defaultValue() if there is no current mapping).
null if there is no current mapping).
ObjShortMap.compute(Object, ObjShortToShortFunction) instead
defaultValue() if there is no current mapping).
ShortByteMap.compute(short, ShortByteToByteFunction) instead
defaultValue() if there is no current mapping).
ShortCharMap.compute(short, ShortCharToCharFunction) instead
defaultValue() if there is no current mapping).
ShortDoubleMap.compute(short, ShortDoubleToDoubleFunction) instead
defaultValue() if there is no current mapping).
ShortFloatMap.compute(short, ShortFloatToFloatFunction) instead
defaultValue() if there is no current mapping).
ShortIntMap.compute(short, ShortIntToIntFunction) instead
defaultValue() if there is no current mapping).
ShortLongMap.compute(short, ShortLongToLongFunction) instead
defaultValue() if there is no current mapping).
ShortObjMap.compute(short, ShortObjFunction) instead
null if there is no current mapping).
ShortShortMap.compute(short, ShortShortToShortFunction) instead
defaultValue() if there is no current mapping).
ByteByteMap.computeIfAbsent(byte, ByteUnaryOperator) instead
ByteCharMap.computeIfAbsent(byte, ByteToCharFunction) instead
ByteDoubleMap.computeIfAbsent(byte, ByteToDoubleFunction) instead
ByteFloatMap.computeIfAbsent(byte, ByteToFloatFunction) instead
ByteIntMap.computeIfAbsent(byte, ByteToIntFunction) instead
ByteLongMap.computeIfAbsent(byte, ByteToLongFunction) instead
ByteObjMap.computeIfAbsent(byte, ByteFunction) instead
null),
attempts to compute its value using the given mapping function
and enters it into this map unless null.
ByteShortMap.computeIfAbsent(byte, ByteToShortFunction) instead
CharByteMap.computeIfAbsent(char, CharToByteFunction) instead
CharCharMap.computeIfAbsent(char, CharUnaryOperator) instead
CharDoubleMap.computeIfAbsent(char, CharToDoubleFunction) instead
CharFloatMap.computeIfAbsent(char, CharToFloatFunction) instead
CharIntMap.computeIfAbsent(char, CharToIntFunction) instead
CharLongMap.computeIfAbsent(char, CharToLongFunction) instead
CharObjMap.computeIfAbsent(char, CharFunction) instead
null),
attempts to compute its value using the given mapping function
and enters it into this map unless null.
CharShortMap.computeIfAbsent(char, CharToShortFunction) instead
DoubleByteMap.computeIfAbsent(double, DoubleToByteFunction) instead
DoubleCharMap.computeIfAbsent(double, DoubleToCharFunction) instead
DoubleDoubleMap.computeIfAbsent(double, DoubleUnaryOperator) instead
DoubleFloatMap.computeIfAbsent(double, DoubleToFloatFunction) instead
DoubleIntMap.computeIfAbsent(double, DoubleToIntFunction) instead
DoubleLongMap.computeIfAbsent(double, DoubleToLongFunction) instead
DoubleObjMap.computeIfAbsent(double, DoubleFunction) instead
null),
attempts to compute its value using the given mapping function
and enters it into this map unless null.
DoubleShortMap.computeIfAbsent(double, DoubleToShortFunction) instead
FloatByteMap.computeIfAbsent(float, FloatToByteFunction) instead
FloatCharMap.computeIfAbsent(float, FloatToCharFunction) instead
FloatDoubleMap.computeIfAbsent(float, FloatToDoubleFunction) instead
FloatFloatMap.computeIfAbsent(float, FloatUnaryOperator) instead
FloatIntMap.computeIfAbsent(float, FloatToIntFunction) instead
FloatLongMap.computeIfAbsent(float, FloatToLongFunction) instead
FloatObjMap.computeIfAbsent(float, FloatFunction) instead
null),
attempts to compute its value using the given mapping function
and enters it into this map unless null.
FloatShortMap.computeIfAbsent(float, FloatToShortFunction) instead
IntByteMap.computeIfAbsent(int, IntToByteFunction) instead
IntCharMap.computeIfAbsent(int, IntToCharFunction) instead
IntDoubleMap.computeIfAbsent(int, IntToDoubleFunction) instead
IntFloatMap.computeIfAbsent(int, IntToFloatFunction) instead
IntIntMap.computeIfAbsent(int, IntUnaryOperator) instead
IntLongMap.computeIfAbsent(int, IntToLongFunction) instead
IntObjMap.computeIfAbsent(int, IntFunction) instead
null),
attempts to compute its value using the given mapping function
and enters it into this map unless null.
IntShortMap.computeIfAbsent(int, IntToShortFunction) instead
LongByteMap.computeIfAbsent(long, LongToByteFunction) instead
LongCharMap.computeIfAbsent(long, LongToCharFunction) instead
LongDoubleMap.computeIfAbsent(long, LongToDoubleFunction) instead
LongFloatMap.computeIfAbsent(long, LongToFloatFunction) instead
LongIntMap.computeIfAbsent(long, LongToIntFunction) instead
LongLongMap.computeIfAbsent(long, LongUnaryOperator) instead
LongObjMap.computeIfAbsent(long, LongFunction) instead
null),
attempts to compute its value using the given mapping function
and enters it into this map unless null.
LongShortMap.computeIfAbsent(long, LongToShortFunction) instead
ObjByteMap.computeIfAbsent(Object, ToByteFunction) instead
ObjCharMap.computeIfAbsent(Object, ToCharFunction) instead
ObjDoubleMap.computeIfAbsent(Object, ToDoubleFunction) instead
ObjFloatMap.computeIfAbsent(Object, ToFloatFunction) instead
ObjIntMap.computeIfAbsent(Object, ToIntFunction) instead
ObjLongMap.computeIfAbsent(Object, ToLongFunction) instead
null),
attempts to compute its value using the given mapping function
and enters it into this map unless null.
ObjShortMap.computeIfAbsent(Object, ToShortFunction) instead
ShortByteMap.computeIfAbsent(short, ShortToByteFunction) instead
ShortCharMap.computeIfAbsent(short, ShortToCharFunction) instead
ShortDoubleMap.computeIfAbsent(short, ShortToDoubleFunction) instead
ShortFloatMap.computeIfAbsent(short, ShortToFloatFunction) instead
ShortIntMap.computeIfAbsent(short, ShortToIntFunction) instead
ShortLongMap.computeIfAbsent(short, ShortToLongFunction) instead
ShortObjMap.computeIfAbsent(short, ShortFunction) instead
null),
attempts to compute its value using the given mapping function
and enters it into this map unless null.
ShortShortMap.computeIfAbsent(short, ShortUnaryOperator) instead
ByteByteMap.computeIfPresent(byte, ByteByteToByteFunction) instead
ByteCharMap.computeIfPresent(byte, ByteCharToCharFunction) instead
ByteDoubleMap.computeIfPresent(byte, ByteDoubleToDoubleFunction) instead
ByteFloatMap.computeIfPresent(byte, ByteFloatToFloatFunction) instead
ByteIntMap.computeIfPresent(byte, ByteIntToIntFunction) instead
ByteLongMap.computeIfPresent(byte, ByteLongToLongFunction) instead
ByteObjMap.computeIfPresent(byte, ByteObjFunction) instead
ByteShortMap.computeIfPresent(byte, ByteShortToShortFunction) instead
CharByteMap.computeIfPresent(char, CharByteToByteFunction) instead
CharCharMap.computeIfPresent(char, CharCharToCharFunction) instead
CharDoubleMap.computeIfPresent(char, CharDoubleToDoubleFunction) instead
CharFloatMap.computeIfPresent(char, CharFloatToFloatFunction) instead
CharIntMap.computeIfPresent(char, CharIntToIntFunction) instead
CharLongMap.computeIfPresent(char, CharLongToLongFunction) instead
CharObjMap.computeIfPresent(char, CharObjFunction) instead
CharShortMap.computeIfPresent(char, CharShortToShortFunction) instead
DoubleByteMap.computeIfPresent(double, DoubleByteToByteFunction) instead
DoubleCharMap.computeIfPresent(double, DoubleCharToCharFunction) instead
DoubleDoubleMap.computeIfPresent(double, DoubleDoubleToDoubleFunction) instead
DoubleFloatMap.computeIfPresent(double, DoubleFloatToFloatFunction) instead
DoubleIntMap.computeIfPresent(double, DoubleIntToIntFunction) instead
DoubleLongMap.computeIfPresent(double, DoubleLongToLongFunction) instead
DoubleObjMap.computeIfPresent(double, DoubleObjFunction) instead
DoubleShortMap.computeIfPresent(double, DoubleShortToShortFunction) instead
FloatByteMap.computeIfPresent(float, FloatByteToByteFunction) instead
FloatCharMap.computeIfPresent(float, FloatCharToCharFunction) instead
FloatDoubleMap.computeIfPresent(float, FloatDoubleToDoubleFunction) instead
FloatFloatMap.computeIfPresent(float, FloatFloatToFloatFunction) instead
FloatIntMap.computeIfPresent(float, FloatIntToIntFunction) instead
FloatLongMap.computeIfPresent(float, FloatLongToLongFunction) instead
FloatObjMap.computeIfPresent(float, FloatObjFunction) instead
FloatShortMap.computeIfPresent(float, FloatShortToShortFunction) instead
IntByteMap.computeIfPresent(int, IntByteToByteFunction) instead
IntCharMap.computeIfPresent(int, IntCharToCharFunction) instead
IntDoubleMap.computeIfPresent(int, IntDoubleToDoubleFunction) instead
IntFloatMap.computeIfPresent(int, IntFloatToFloatFunction) instead
IntIntMap.computeIfPresent(int, IntIntToIntFunction) instead
IntLongMap.computeIfPresent(int, IntLongToLongFunction) instead
IntObjMap.computeIfPresent(int, IntObjFunction) instead
IntShortMap.computeIfPresent(int, IntShortToShortFunction) instead
LongByteMap.computeIfPresent(long, LongByteToByteFunction) instead
LongCharMap.computeIfPresent(long, LongCharToCharFunction) instead
LongDoubleMap.computeIfPresent(long, LongDoubleToDoubleFunction) instead
LongFloatMap.computeIfPresent(long, LongFloatToFloatFunction) instead
LongIntMap.computeIfPresent(long, LongIntToIntFunction) instead
LongLongMap.computeIfPresent(long, LongLongToLongFunction) instead
LongObjMap.computeIfPresent(long, LongObjFunction) instead
LongShortMap.computeIfPresent(long, LongShortToShortFunction) instead
ObjByteMap.computeIfPresent(Object, ObjByteToByteFunction) instead
ObjCharMap.computeIfPresent(Object, ObjCharToCharFunction) instead
ObjDoubleMap.computeIfPresent(Object, ObjDoubleToDoubleFunction) instead
ObjFloatMap.computeIfPresent(Object, ObjFloatToFloatFunction) instead
ObjIntMap.computeIfPresent(Object, ObjIntToIntFunction) instead
ObjLongMap.computeIfPresent(Object, ObjLongToLongFunction) instead
ObjShortMap.computeIfPresent(Object, ObjShortToShortFunction) instead
ShortByteMap.computeIfPresent(short, ShortByteToByteFunction) instead
ShortCharMap.computeIfPresent(short, ShortCharToCharFunction) instead
ShortDoubleMap.computeIfPresent(short, ShortDoubleToDoubleFunction) instead
ShortFloatMap.computeIfPresent(short, ShortFloatToFloatFunction) instead
ShortIntMap.computeIfPresent(short, ShortIntToIntFunction) instead
ShortLongMap.computeIfPresent(short, ShortLongToLongFunction) instead
ShortObjMap.computeIfPresent(short, ShortObjFunction) instead
ShortShortMap.computeIfPresent(short, ShortShortToShortFunction) instead
ByteCollection.contains(byte) instead
true if this collection contains at least one element
equals to the specified one.
CharCollection.contains(char) instead
true if this collection contains at least one element
equals to the specified one.
DoubleCollection.contains(double) instead
true if this collection contains at least one element
equals to the specified one.
FloatCollection.contains(float) instead
true if this collection contains at least one element
equals to the specified one.
IntCollection.contains(int) instead
true if this collection contains at least one element
equals to the specified one.
LongCollection.contains(long) instead
true if this collection contains at least one element
equals to the specified one.
ShortCollection.contains(short) instead
true if this collection contains at least one element
equals to the specified one.
ByteByteMap.containsKey(byte) instead
ByteCharMap.containsKey(byte) instead
ByteDoubleMap.containsKey(byte) instead
ByteFloatMap.containsKey(byte) instead
ByteIntMap.containsKey(byte) instead
ByteLongMap.containsKey(byte) instead
ByteObjMap.containsKey(byte) instead
ByteShortMap.containsKey(byte) instead
CharByteMap.containsKey(char) instead
CharCharMap.containsKey(char) instead
CharDoubleMap.containsKey(char) instead
CharFloatMap.containsKey(char) instead
CharIntMap.containsKey(char) instead
CharLongMap.containsKey(char) instead
CharObjMap.containsKey(char) instead
CharShortMap.containsKey(char) instead
DoubleByteMap.containsKey(double) instead
DoubleCharMap.containsKey(double) instead
DoubleDoubleMap.containsKey(double) instead
DoubleFloatMap.containsKey(double) instead
DoubleIntMap.containsKey(double) instead
DoubleLongMap.containsKey(double) instead
DoubleObjMap.containsKey(double) instead
DoubleShortMap.containsKey(double) instead
FloatByteMap.containsKey(float) instead
FloatCharMap.containsKey(float) instead
FloatDoubleMap.containsKey(float) instead
FloatFloatMap.containsKey(float) instead
FloatIntMap.containsKey(float) instead
FloatLongMap.containsKey(float) instead
FloatObjMap.containsKey(float) instead
FloatShortMap.containsKey(float) instead
IntByteMap.containsKey(int) instead
IntCharMap.containsKey(int) instead
IntDoubleMap.containsKey(int) instead
IntFloatMap.containsKey(int) instead
IntIntMap.containsKey(int) instead
IntLongMap.containsKey(int) instead
IntObjMap.containsKey(int) instead
IntShortMap.containsKey(int) instead
LongByteMap.containsKey(long) instead
LongCharMap.containsKey(long) instead
LongDoubleMap.containsKey(long) instead
LongFloatMap.containsKey(long) instead
LongIntMap.containsKey(long) instead
LongLongMap.containsKey(long) instead
LongObjMap.containsKey(long) instead
LongShortMap.containsKey(long) instead
ShortByteMap.containsKey(short) instead
ShortCharMap.containsKey(short) instead
ShortDoubleMap.containsKey(short) instead
ShortFloatMap.containsKey(short) instead
ShortIntMap.containsKey(short) instead
ShortLongMap.containsKey(short) instead
ShortObjMap.containsKey(short) instead
ShortShortMap.containsKey(short) instead
ByteByteMap.containsValue(byte) instead
ByteCharMap.containsValue(char) instead
ByteDoubleMap.containsValue(double) instead
ByteFloatMap.containsValue(float) instead
ByteIntMap.containsValue(int) instead
ByteLongMap.containsValue(long) instead
ByteShortMap.containsValue(short) instead
CharByteMap.containsValue(byte) instead
CharCharMap.containsValue(char) instead
CharDoubleMap.containsValue(double) instead
CharFloatMap.containsValue(float) instead
CharIntMap.containsValue(int) instead
CharLongMap.containsValue(long) instead
CharShortMap.containsValue(short) instead
DoubleByteMap.containsValue(byte) instead
DoubleCharMap.containsValue(char) instead
DoubleDoubleMap.containsValue(double) instead
DoubleFloatMap.containsValue(float) instead
DoubleIntMap.containsValue(int) instead
DoubleLongMap.containsValue(long) instead
DoubleShortMap.containsValue(short) instead
FloatByteMap.containsValue(byte) instead
FloatCharMap.containsValue(char) instead
FloatDoubleMap.containsValue(double) instead
FloatFloatMap.containsValue(float) instead
FloatIntMap.containsValue(int) instead
FloatLongMap.containsValue(long) instead
FloatShortMap.containsValue(short) instead
IntByteMap.containsValue(byte) instead
IntCharMap.containsValue(char) instead
IntDoubleMap.containsValue(double) instead
IntFloatMap.containsValue(float) instead
IntIntMap.containsValue(int) instead
IntLongMap.containsValue(long) instead
IntShortMap.containsValue(short) instead
LongByteMap.containsValue(byte) instead
LongCharMap.containsValue(char) instead
LongDoubleMap.containsValue(double) instead
LongFloatMap.containsValue(float) instead
LongIntMap.containsValue(int) instead
LongLongMap.containsValue(long) instead
LongShortMap.containsValue(short) instead
ObjByteMap.containsValue(byte) instead
ObjCharMap.containsValue(char) instead
ObjDoubleMap.containsValue(double) instead
ObjFloatMap.containsValue(float) instead
ObjIntMap.containsValue(int) instead
ObjLongMap.containsValue(long) instead
ObjShortMap.containsValue(short) instead
ShortByteMap.containsValue(byte) instead
ShortCharMap.containsValue(char) instead
ShortDoubleMap.containsValue(double) instead
ShortFloatMap.containsValue(float) instead
ShortIntMap.containsValue(int) instead
ShortLongMap.containsValue(long) instead
ShortShortMap.containsValue(short) instead
Object keys and
double values.Map specialization with double keys
and byte values.Object keys and
double values.Map specialization with double keys
and char values.doubles.Object keys and
double values.Map specialization with double keys
and double values.Object keys and
double values.Map specialization with double keys
and float values.Object keys and
double values.Map specialization with double keys
and int values.Object keys and
double values.Map specialization with double keys
and long values.Object keys and
double values.Map specialization with double keys
and Object values.Object keys and
double values.Map specialization with double keys
and short values.minSize elements.
minSize - Container.size() new elements without
excessive rehashes.
true if the given object is also an instance of this equivalence class.
Object keys and
float values.Map specialization with float keys
and byte values.Object keys and
float values.Map specialization with float keys
and char values.floats.Object keys and
float values.Map specialization with float keys
and double values.Object keys and
float values.Map specialization with float keys
and float values.Object keys and
float values.Map specialization with float keys
and int values.Object keys and
float values.Map specialization with float keys
and long values.Object keys and
float values.Map specialization with float keys
and Object values.Object keys and
float values.Map specialization with float keys
and short values.ByteCollection.forEach(ByteConsumer) instead
CharCollection.forEach(CharConsumer) instead
DoubleCollection.forEach(DoubleConsumer) instead
FloatCollection.forEach(FloatConsumer) instead
IntCollection.forEach(IntConsumer) instead
LongCollection.forEach(LongConsumer) instead
ByteByteMap.forEach(ByteByteConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ByteCharMap.forEach(ByteCharConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ByteDoubleMap.forEach(ByteDoubleConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ByteFloatMap.forEach(ByteFloatConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ByteIntMap.forEach(ByteIntConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ByteLongMap.forEach(ByteLongConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ByteObjMap.forEach(ByteObjConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ByteShortMap.forEach(ByteShortConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
CharByteMap.forEach(CharByteConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
CharCharMap.forEach(CharCharConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
CharDoubleMap.forEach(CharDoubleConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
CharFloatMap.forEach(CharFloatConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
CharIntMap.forEach(CharIntConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
CharLongMap.forEach(CharLongConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
CharObjMap.forEach(CharObjConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
CharShortMap.forEach(CharShortConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
DoubleByteMap.forEach(DoubleByteConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
DoubleCharMap.forEach(DoubleCharConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
DoubleDoubleMap.forEach(DoubleDoubleConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
DoubleFloatMap.forEach(DoubleFloatConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
DoubleIntMap.forEach(DoubleIntConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
DoubleLongMap.forEach(DoubleLongConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
DoubleObjMap.forEach(DoubleObjConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
DoubleShortMap.forEach(DoubleShortConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
FloatByteMap.forEach(FloatByteConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
FloatCharMap.forEach(FloatCharConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
FloatDoubleMap.forEach(FloatDoubleConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
FloatFloatMap.forEach(FloatFloatConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
FloatIntMap.forEach(FloatIntConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
FloatLongMap.forEach(FloatLongConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
FloatObjMap.forEach(FloatObjConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
FloatShortMap.forEach(FloatShortConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
IntByteMap.forEach(IntByteConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
IntCharMap.forEach(IntCharConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
IntDoubleMap.forEach(IntDoubleConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
IntFloatMap.forEach(IntFloatConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
IntIntMap.forEach(IntIntConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
IntLongMap.forEach(IntLongConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
IntObjMap.forEach(IntObjConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
IntShortMap.forEach(IntShortConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
LongByteMap.forEach(LongByteConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
LongCharMap.forEach(LongCharConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
LongDoubleMap.forEach(LongDoubleConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
LongFloatMap.forEach(LongFloatConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
LongIntMap.forEach(LongIntConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
LongLongMap.forEach(LongLongConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
LongObjMap.forEach(LongObjConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
LongShortMap.forEach(LongShortConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ObjByteMap.forEach(ObjByteConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ObjCharMap.forEach(ObjCharConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ObjDoubleMap.forEach(ObjDoubleConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ObjFloatMap.forEach(ObjFloatConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ObjIntMap.forEach(ObjIntConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ObjLongMap.forEach(ObjLongConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ObjShortMap.forEach(ObjShortConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ShortByteMap.forEach(ShortByteConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ShortCharMap.forEach(ShortCharConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ShortDoubleMap.forEach(ShortDoubleConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ShortFloatMap.forEach(ShortFloatConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ShortIntMap.forEach(ShortIntConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ShortLongMap.forEach(ShortLongConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ShortObjMap.forEach(ShortObjConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ShortShortMap.forEach(ShortShortConsumer) instead
action on each entry in this map until all entries
have been processed or the action throws an Exception.
ShortCollection.forEach(ShortConsumer) instead
ByteIterator.forEachRemaining(ByteConsumer) instead
CharIterator.forEachRemaining(CharConsumer) instead
DoubleIterator.forEachRemaining(DoubleConsumer) instead
FloatIterator.forEachRemaining(FloatConsumer) instead
IntIterator.forEachRemaining(IntConsumer) instead
LongIterator.forEachRemaining(LongConsumer) instead
ShortIterator.forEachRemaining(ShortConsumer) instead
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
predicate on each entry in this map until all entries
have been processed or the predicate returns false for some entry,
or the action throws an Exception.
ByteByteMap.get(byte) instead
ByteCharMap.get(byte) instead
ByteDoubleMap.get(byte) instead
ByteFloatMap.get(byte) instead
ByteIntMap.get(byte) instead
ByteLongMap.get(byte) instead
ByteObjMap.get(byte) instead
ByteShortMap.get(byte) instead
CharByteMap.get(char) instead
CharCharMap.get(char) instead
CharDoubleMap.get(char) instead
CharFloatMap.get(char) instead
CharIntMap.get(char) instead
CharLongMap.get(char) instead
CharObjMap.get(char) instead
CharShortMap.get(char) instead
DoubleByteMap.get(double) instead
DoubleCharMap.get(double) instead
DoubleDoubleMap.get(double) instead
DoubleFloatMap.get(double) instead
DoubleIntMap.get(double) instead
DoubleLongMap.get(double) instead
DoubleObjMap.get(double) instead
DoubleShortMap.get(double) instead
FloatByteMap.get(float) instead
FloatCharMap.get(float) instead
FloatDoubleMap.get(float) instead
FloatFloatMap.get(float) instead
FloatIntMap.get(float) instead
FloatLongMap.get(float) instead
FloatObjMap.get(float) instead
FloatShortMap.get(float) instead
IntByteMap.get(int) instead
IntCharMap.get(int) instead
IntDoubleMap.get(int) instead
IntFloatMap.get(int) instead
IntIntMap.get(int) instead
IntLongMap.get(int) instead
IntObjMap.get(int) instead
IntShortMap.get(int) instead
LongByteMap.get(long) instead
LongCharMap.get(long) instead
LongDoubleMap.get(long) instead
LongFloatMap.get(long) instead
LongIntMap.get(long) instead
LongLongMap.get(long) instead
LongObjMap.get(long) instead
LongShortMap.get(long) instead
ObjByteMap.getByte(Object) instead
ObjCharMap.getChar(Object) instead
ObjDoubleMap.getDouble(Object) instead
ObjFloatMap.getFloat(Object) instead
ObjIntMap.getInt(Object) instead
ObjLongMap.getLong(Object) instead
ObjShortMap.getShort(Object) instead
ShortByteMap.get(short) instead
ShortCharMap.get(short) instead
ShortDoubleMap.get(short) instead
ShortFloatMap.get(short) instead
ShortIntMap.get(short) instead
ShortLongMap.get(short) instead
ShortObjMap.get(short) instead
ShortShortMap.get(short) instead
null shrink condition
and 10 default expected size.
ByteByteMap.getOrDefault(byte, byte) instead
defaultValue if this map contains no mapping for the key.
ByteCharMap.getOrDefault(byte, char) instead
defaultValue if this map contains no mapping for the key.
ByteDoubleMap.getOrDefault(byte, double) instead
defaultValue if this map contains no mapping for the key.
ByteFloatMap.getOrDefault(byte, float) instead
defaultValue if this map contains no mapping for the key.
ByteIntMap.getOrDefault(byte, int) instead
defaultValue if this map contains no mapping for the key.
ByteLongMap.getOrDefault(byte, long) instead
defaultValue if this map contains no mapping for the key.
ByteObjMap.getOrDefault(byte, Object) instead
defaultValue if this map contains no mapping for the key.
ByteShortMap.getOrDefault(byte, short) instead
defaultValue if this map contains no mapping for the key.
CharByteMap.getOrDefault(char, byte) instead
defaultValue if this map contains no mapping for the key.
CharCharMap.getOrDefault(char, char) instead
defaultValue if this map contains no mapping for the key.
CharDoubleMap.getOrDefault(char, double) instead
defaultValue if this map contains no mapping for the key.
CharFloatMap.getOrDefault(char, float) instead
defaultValue if this map contains no mapping for the key.
CharIntMap.getOrDefault(char, int) instead
defaultValue if this map contains no mapping for the key.
CharLongMap.getOrDefault(char, long) instead
defaultValue if this map contains no mapping for the key.
CharObjMap.getOrDefault(char, Object) instead
defaultValue if this map contains no mapping for the key.
CharShortMap.getOrDefault(char, short) instead
defaultValue if this map contains no mapping for the key.
DoubleByteMap.getOrDefault(double, byte) instead
defaultValue if this map contains no mapping for the key.
DoubleCharMap.getOrDefault(double, char) instead
defaultValue if this map contains no mapping for the key.
DoubleDoubleMap.getOrDefault(double, double) instead
defaultValue if this map contains no mapping for the key.
DoubleFloatMap.getOrDefault(double, float) instead
defaultValue if this map contains no mapping for the key.
DoubleIntMap.getOrDefault(double, int) instead
defaultValue if this map contains no mapping for the key.
DoubleLongMap.getOrDefault(double, long) instead
defaultValue if this map contains no mapping for the key.
DoubleObjMap.getOrDefault(double, Object) instead
defaultValue if this map contains no mapping for the key.
DoubleShortMap.getOrDefault(double, short) instead
defaultValue if this map contains no mapping for the key.
FloatByteMap.getOrDefault(float, byte) instead
defaultValue if this map contains no mapping for the key.
FloatCharMap.getOrDefault(float, char) instead
defaultValue if this map contains no mapping for the key.
FloatDoubleMap.getOrDefault(float, double) instead
defaultValue if this map contains no mapping for the key.
FloatFloatMap.getOrDefault(float, float) instead
defaultValue if this map contains no mapping for the key.
FloatIntMap.getOrDefault(float, int) instead
defaultValue if this map contains no mapping for the key.
FloatLongMap.getOrDefault(float, long) instead
defaultValue if this map contains no mapping for the key.
FloatObjMap.getOrDefault(float, Object) instead
defaultValue if this map contains no mapping for the key.
FloatShortMap.getOrDefault(float, short) instead
defaultValue if this map contains no mapping for the key.
IntByteMap.getOrDefault(int, byte) instead
defaultValue if this map contains no mapping for the key.
IntCharMap.getOrDefault(int, char) instead
defaultValue if this map contains no mapping for the key.
IntDoubleMap.getOrDefault(int, double) instead
defaultValue if this map contains no mapping for the key.
IntFloatMap.getOrDefault(int, float) instead
defaultValue if this map contains no mapping for the key.
IntIntMap.getOrDefault(int, int) instead
defaultValue if this map contains no mapping for the key.
IntLongMap.getOrDefault(int, long) instead
defaultValue if this map contains no mapping for the key.
IntObjMap.getOrDefault(int, Object) instead
defaultValue if this map contains no mapping for the key.
IntShortMap.getOrDefault(int, short) instead
defaultValue if this map contains no mapping for the key.
LongByteMap.getOrDefault(long, byte) instead
defaultValue if this map contains no mapping for the key.
LongCharMap.getOrDefault(long, char) instead
defaultValue if this map contains no mapping for the key.
LongDoubleMap.getOrDefault(long, double) instead
defaultValue if this map contains no mapping for the key.
LongFloatMap.getOrDefault(long, float) instead
defaultValue if this map contains no mapping for the key.
LongIntMap.getOrDefault(long, int) instead
defaultValue if this map contains no mapping for the key.
LongLongMap.getOrDefault(long, long) instead
defaultValue if this map contains no mapping for the key.
LongObjMap.getOrDefault(long, Object) instead
defaultValue if this map contains no mapping for the key.
LongShortMap.getOrDefault(long, short) instead
defaultValue if this map contains no mapping for the key.
ObjByteMap.getOrDefault(Object, byte) instead
defaultValue if this map contains no mapping for the key.
ObjCharMap.getOrDefault(Object, char) instead
defaultValue if this map contains no mapping for the key.
ObjDoubleMap.getOrDefault(Object, double) instead
defaultValue if this map contains no mapping for the key.
ObjFloatMap.getOrDefault(Object, float) instead
defaultValue if this map contains no mapping for the key.
ObjIntMap.getOrDefault(Object, int) instead
defaultValue if this map contains no mapping for the key.
ObjLongMap.getOrDefault(Object, long) instead
defaultValue if this map contains no mapping for the key.
defaultValue if this map contains no mapping for the key.
ObjShortMap.getOrDefault(Object, short) instead
defaultValue if this map contains no mapping for the key.
ShortByteMap.getOrDefault(short, byte) instead
defaultValue if this map contains no mapping for the key.
ShortCharMap.getOrDefault(short, char) instead
defaultValue if this map contains no mapping for the key.
ShortDoubleMap.getOrDefault(short, double) instead
defaultValue if this map contains no mapping for the key.
ShortFloatMap.getOrDefault(short, float) instead
defaultValue if this map contains no mapping for the key.
ShortIntMap.getOrDefault(short, int) instead
defaultValue if this map contains no mapping for the key.
ShortLongMap.getOrDefault(short, long) instead
defaultValue if this map contains no mapping for the key.
ShortObjMap.getOrDefault(short, Object) instead
defaultValue if this map contains no mapping for the key.
ShortShortMap.getOrDefault(short, short) instead
defaultValue if this map contains no mapping for the key.
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
byte newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
char newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
double newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
float newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
int newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
long newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
short newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
byte newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
char newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
double newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
float newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
int newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
long newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
short newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
byte newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
char newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
double newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
float newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
int newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
long newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
short newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
byte newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
char newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
double newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
float newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
int newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
long newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
short newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
byte newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
char newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
double newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
float newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
int newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
long newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
short newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
byte newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
char newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
double newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
float newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
int newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
long newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
short newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
byte newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
char newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
double newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
float newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
int newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
long newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
short newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
byte newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
char newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
double newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
float newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
int newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
long newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
map.incrementValue(key, inc) is equivalent
of map.compute(key, (k, v) -> v + inc).
map.incrementValue(key, increment, defaultValue) is equivalent to
short newValue = map.getOrDefault(key, defaultValue) + increment;
map.put(key, newValue);
return newValue;
Object keys and
int values.Map specialization with int keys
and byte values.Object keys and
int values.Map specialization with int keys
and char values.ints.Object keys and
int values.Map specialization with int keys
and double values.Object keys and
int values.Map specialization with int keys
and float values.Object keys and
int values.Map specialization with int keys
and int values.Object keys and
int values.Map specialization with int keys
and long values.Object keys and
int values.Map specialization with int keys
and Object values.Object keys and
int values.Map specialization with int keys
and short values.NullPointerException on putting null as a key, although they could,
if null key is disallowed.
Object keys and
long values.Map specialization with long keys
and byte values.Object keys and
long values.Map specialization with long keys
and char values.longs.Object keys and
long values.Map specialization with long keys
and double values.Object keys and
long values.Map specialization with long keys
and float values.Object keys and
long values.Map specialization with long keys
and int values.Object keys and
long values.Map specialization with long keys
and long values.Object keys and
long values.Map specialization with long keys
and Object values.Object keys and
long values.Map specialization with long keys
and short values.ByteByteMap.merge(byte, byte, ByteBinaryOperator) instead
ByteCharMap.merge(byte, char, CharBinaryOperator) instead
ByteDoubleMap.merge(byte, double, DoubleBinaryOperator) instead
ByteFloatMap.merge(byte, float, FloatBinaryOperator) instead
ByteIntMap.merge(byte, int, IntBinaryOperator) instead
ByteLongMap.merge(byte, long, LongBinaryOperator) instead
ByteObjMap.merge(byte, Object, BiFunction) instead
null),
associates it with the given value.
ByteShortMap.merge(byte, short, ShortBinaryOperator) instead
CharByteMap.merge(char, byte, ByteBinaryOperator) instead
CharCharMap.merge(char, char, CharBinaryOperator) instead
CharDoubleMap.merge(char, double, DoubleBinaryOperator) instead
CharFloatMap.merge(char, float, FloatBinaryOperator) instead
CharIntMap.merge(char, int, IntBinaryOperator) instead
CharLongMap.merge(char, long, LongBinaryOperator) instead
CharObjMap.merge(char, Object, BiFunction) instead
null),
associates it with the given value.
CharShortMap.merge(char, short, ShortBinaryOperator) instead
DoubleByteMap.merge(double, byte, ByteBinaryOperator) instead
DoubleCharMap.merge(double, char, CharBinaryOperator) instead
DoubleDoubleMap.merge(double, double, DoubleBinaryOperator) instead
DoubleFloatMap.merge(double, float, FloatBinaryOperator) instead
DoubleIntMap.merge(double, int, IntBinaryOperator) instead
DoubleLongMap.merge(double, long, LongBinaryOperator) instead
DoubleObjMap.merge(double, Object, BiFunction) instead
null),
associates it with the given value.
DoubleShortMap.merge(double, short, ShortBinaryOperator) instead
FloatByteMap.merge(float, byte, ByteBinaryOperator) instead
FloatCharMap.merge(float, char, CharBinaryOperator) instead
FloatDoubleMap.merge(float, double, DoubleBinaryOperator) instead
FloatFloatMap.merge(float, float, FloatBinaryOperator) instead
FloatIntMap.merge(float, int, IntBinaryOperator) instead
FloatLongMap.merge(float, long, LongBinaryOperator) instead
FloatObjMap.merge(float, Object, BiFunction) instead
null),
associates it with the given value.
FloatShortMap.merge(float, short, ShortBinaryOperator) instead
IntByteMap.merge(int, byte, ByteBinaryOperator) instead
IntCharMap.merge(int, char, CharBinaryOperator) instead
IntDoubleMap.merge(int, double, DoubleBinaryOperator) instead
IntFloatMap.merge(int, float, FloatBinaryOperator) instead
IntIntMap.merge(int, int, IntBinaryOperator) instead
IntLongMap.merge(int, long, LongBinaryOperator) instead
IntObjMap.merge(int, Object, BiFunction) instead
null),
associates it with the given value.
IntShortMap.merge(int, short, ShortBinaryOperator) instead
LongByteMap.merge(long, byte, ByteBinaryOperator) instead
LongCharMap.merge(long, char, CharBinaryOperator) instead
LongDoubleMap.merge(long, double, DoubleBinaryOperator) instead
LongFloatMap.merge(long, float, FloatBinaryOperator) instead
LongIntMap.merge(long, int, IntBinaryOperator) instead
LongLongMap.merge(long, long, LongBinaryOperator) instead
LongObjMap.merge(long, Object, BiFunction) instead
null),
associates it with the given value.
LongShortMap.merge(long, short, ShortBinaryOperator) instead
ObjByteMap.merge(Object, byte, ByteBinaryOperator) instead
ObjCharMap.merge(Object, char, CharBinaryOperator) instead
ObjDoubleMap.merge(Object, double, DoubleBinaryOperator) instead
ObjFloatMap.merge(Object, float, FloatBinaryOperator) instead
ObjIntMap.merge(Object, int, IntBinaryOperator) instead
ObjLongMap.merge(Object, long, LongBinaryOperator) instead
null),
associates it with the given value.
ObjShortMap.merge(Object, short, ShortBinaryOperator) instead
ShortByteMap.merge(short, byte, ByteBinaryOperator) instead
ShortCharMap.merge(short, char, CharBinaryOperator) instead
ShortDoubleMap.merge(short, double, DoubleBinaryOperator) instead
ShortFloatMap.merge(short, float, FloatBinaryOperator) instead
ShortIntMap.merge(short, int, IntBinaryOperator) instead
ShortLongMap.merge(short, long, LongBinaryOperator) instead
ShortObjMap.merge(short, Object, BiFunction) instead
null),
associates it with the given value.
ShortShortMap.merge(short, short, ShortBinaryOperator) instead
true if it exists, false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
true if it exists,
false otherwise.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
expectedSize is ignored.
Object keys and
K values.Map specialization with Object keys
and byte values.Object keys and
K values.Map specialization with Object keys
and char values.Object keys and
K values.Map specialization with Object keys
and double values.Object keys and
K values.Map specialization with Object keys
and float values.Object keys and
K values.Map specialization with Object keys
and int values.Object keys and
K values.Map specialization with Object keys
and long values.Object keys and
K values.Map specialization with Object keys
and Object values.Object keys and
K values.Map specialization with Object keys
and short values.ByteByteMap.put(byte, byte) instead
ByteCharMap.put(byte, char) instead
ByteDoubleMap.put(byte, double) instead
ByteFloatMap.put(byte, float) instead
ByteIntMap.put(byte, int) instead
ByteLongMap.put(byte, long) instead
ByteObjMap.put(byte, Object) instead
ByteShortMap.put(byte, short) instead
CharByteMap.put(char, byte) instead
CharCharMap.put(char, char) instead
CharDoubleMap.put(char, double) instead
CharFloatMap.put(char, float) instead
CharIntMap.put(char, int) instead
CharLongMap.put(char, long) instead
CharObjMap.put(char, Object) instead
CharShortMap.put(char, short) instead
DoubleByteMap.put(double, byte) instead
DoubleCharMap.put(double, char) instead
DoubleDoubleMap.put(double, double) instead
DoubleFloatMap.put(double, float) instead
DoubleIntMap.put(double, int) instead
DoubleLongMap.put(double, long) instead
DoubleObjMap.put(double, Object) instead
DoubleShortMap.put(double, short) instead
FloatByteMap.put(float, byte) instead
FloatCharMap.put(float, char) instead
FloatDoubleMap.put(float, double) instead
FloatFloatMap.put(float, float) instead
FloatIntMap.put(float, int) instead
FloatLongMap.put(float, long) instead
FloatObjMap.put(float, Object) instead
FloatShortMap.put(float, short) instead
IntByteMap.put(int, byte) instead
IntCharMap.put(int, char) instead
IntDoubleMap.put(int, double) instead
IntFloatMap.put(int, float) instead
IntIntMap.put(int, int) instead
IntLongMap.put(int, long) instead
IntObjMap.put(int, Object) instead
IntShortMap.put(int, short) instead
LongByteMap.put(long, byte) instead
LongCharMap.put(long, char) instead
LongDoubleMap.put(long, double) instead
LongFloatMap.put(long, float) instead
LongIntMap.put(long, int) instead
LongLongMap.put(long, long) instead
LongObjMap.put(long, Object) instead
LongShortMap.put(long, short) instead
ObjByteMap.put(Object, byte) instead
ObjCharMap.put(Object, char) instead
ObjDoubleMap.put(Object, double) instead
ObjFloatMap.put(Object, float) instead
ObjIntMap.put(Object, int) instead
ObjLongMap.put(Object, long) instead
ObjShortMap.put(Object, short) instead
ShortByteMap.put(short, byte) instead
ShortCharMap.put(short, char) instead
ShortDoubleMap.put(short, double) instead
ShortFloatMap.put(short, float) instead
ShortIntMap.put(short, int) instead
ShortLongMap.put(short, long) instead
ShortObjMap.put(short, Object) instead
ShortShortMap.put(short, short) instead
ByteByteMap.putIfAbsent(byte, byte) instead
defaultValue(),
else returns the current value.
ByteCharMap.putIfAbsent(byte, char) instead
defaultValue(),
else returns the current value.
ByteDoubleMap.putIfAbsent(byte, double) instead
defaultValue(),
else returns the current value.
ByteFloatMap.putIfAbsent(byte, float) instead
defaultValue(),
else returns the current value.
ByteIntMap.putIfAbsent(byte, int) instead
defaultValue(),
else returns the current value.
ByteLongMap.putIfAbsent(byte, long) instead
defaultValue(),
else returns the current value.
ByteObjMap.putIfAbsent(byte, Object) instead
null),
associates it with the given value and returns null,
else returns the current value.
ByteShortMap.putIfAbsent(byte, short) instead
defaultValue(),
else returns the current value.
CharByteMap.putIfAbsent(char, byte) instead
defaultValue(),
else returns the current value.
CharCharMap.putIfAbsent(char, char) instead
defaultValue(),
else returns the current value.
CharDoubleMap.putIfAbsent(char, double) instead
defaultValue(),
else returns the current value.
CharFloatMap.putIfAbsent(char, float) instead
defaultValue(),
else returns the current value.
CharIntMap.putIfAbsent(char, int) instead
defaultValue(),
else returns the current value.
CharLongMap.putIfAbsent(char, long) instead
defaultValue(),
else returns the current value.
CharObjMap.putIfAbsent(char, Object) instead
null),
associates it with the given value and returns null,
else returns the current value.
CharShortMap.putIfAbsent(char, short) instead
defaultValue(),
else returns the current value.
DoubleByteMap.putIfAbsent(double, byte) instead
defaultValue(),
else returns the current value.
DoubleCharMap.putIfAbsent(double, char) instead
defaultValue(),
else returns the current value.
DoubleDoubleMap.putIfAbsent(double, double) instead
defaultValue(),
else returns the current value.
DoubleFloatMap.putIfAbsent(double, float) instead
defaultValue(),
else returns the current value.
DoubleIntMap.putIfAbsent(double, int) instead
defaultValue(),
else returns the current value.
DoubleLongMap.putIfAbsent(double, long) instead
defaultValue(),
else returns the current value.
DoubleObjMap.putIfAbsent(double, Object) instead
null),
associates it with the given value and returns null,
else returns the current value.
DoubleShortMap.putIfAbsent(double, short) instead
defaultValue(),
else returns the current value.
FloatByteMap.putIfAbsent(float, byte) instead
defaultValue(),
else returns the current value.
FloatCharMap.putIfAbsent(float, char) instead
defaultValue(),
else returns the current value.
FloatDoubleMap.putIfAbsent(float, double) instead
defaultValue(),
else returns the current value.
FloatFloatMap.putIfAbsent(float, float) instead
defaultValue(),
else returns the current value.
FloatIntMap.putIfAbsent(float, int) instead
defaultValue(),
else returns the current value.
FloatLongMap.putIfAbsent(float, long) instead
defaultValue(),
else returns the current value.
FloatObjMap.putIfAbsent(float, Object) instead
null),
associates it with the given value and returns null,
else returns the current value.
FloatShortMap.putIfAbsent(float, short) instead
defaultValue(),
else returns the current value.
IntByteMap.putIfAbsent(int, byte) instead
defaultValue(),
else returns the current value.
IntCharMap.putIfAbsent(int, char) instead
defaultValue(),
else returns the current value.
IntDoubleMap.putIfAbsent(int, double) instead
defaultValue(),
else returns the current value.
IntFloatMap.putIfAbsent(int, float) instead
defaultValue(),
else returns the current value.
IntIntMap.putIfAbsent(int, int) instead
defaultValue(),
else returns the current value.
IntLongMap.putIfAbsent(int, long) instead
defaultValue(),
else returns the current value.
IntObjMap.putIfAbsent(int, Object) instead
null),
associates it with the given value and returns null,
else returns the current value.
IntShortMap.putIfAbsent(int, short) instead
defaultValue(),
else returns the current value.
LongByteMap.putIfAbsent(long, byte) instead
defaultValue(),
else returns the current value.
LongCharMap.putIfAbsent(long, char) instead
defaultValue(),
else returns the current value.
LongDoubleMap.putIfAbsent(long, double) instead
defaultValue(),
else returns the current value.
LongFloatMap.putIfAbsent(long, float) instead
defaultValue(),
else returns the current value.
LongIntMap.putIfAbsent(long, int) instead
defaultValue(),
else returns the current value.
LongLongMap.putIfAbsent(long, long) instead
defaultValue(),
else returns the current value.
LongObjMap.putIfAbsent(long, Object) instead
null),
associates it with the given value and returns null,
else returns the current value.
LongShortMap.putIfAbsent(long, short) instead
defaultValue(),
else returns the current value.
ObjByteMap.putIfAbsent(Object, byte) instead
defaultValue(),
else returns the current value.
ObjCharMap.putIfAbsent(Object, char) instead
defaultValue(),
else returns the current value.
ObjDoubleMap.putIfAbsent(Object, double) instead
defaultValue(),
else returns the current value.
ObjFloatMap.putIfAbsent(Object, float) instead
defaultValue(),
else returns the current value.
ObjIntMap.putIfAbsent(Object, int) instead
defaultValue(),
else returns the current value.
ObjLongMap.putIfAbsent(Object, long) instead
defaultValue(),
else returns the current value.
null),
associates it with the given value and returns null,
else returns the current value.
ObjShortMap.putIfAbsent(Object, short) instead
defaultValue(),
else returns the current value.
ShortByteMap.putIfAbsent(short, byte) instead
defaultValue(),
else returns the current value.
ShortCharMap.putIfAbsent(short, char) instead
defaultValue(),
else returns the current value.
ShortDoubleMap.putIfAbsent(short, double) instead
defaultValue(),
else returns the current value.
ShortFloatMap.putIfAbsent(short, float) instead
defaultValue(),
else returns the current value.
ShortIntMap.putIfAbsent(short, int) instead
defaultValue(),
else returns the current value.
ShortLongMap.putIfAbsent(short, long) instead
defaultValue(),
else returns the current value.
ShortObjMap.putIfAbsent(short, Object) instead
null),
associates it with the given value and returns null,
else returns the current value.
ShortShortMap.putIfAbsent(short, short) instead
defaultValue(),
else returns the current value.
ByteCollection.removeByte(byte) instead
CharCollection.removeChar(char) instead
DoubleCollection.removeDouble(double) instead
FloatCollection.removeFloat(float) instead
IntCollection.removeInt(int) instead
LongCollection.removeLong(long) instead
ByteByteMap.remove(byte) instead
ByteByteMap.remove(byte, byte) instead
ByteCharMap.remove(byte) instead
ByteCharMap.remove(byte, char) instead
ByteDoubleMap.remove(byte) instead
ByteDoubleMap.remove(byte, double) instead
ByteFloatMap.remove(byte) instead
ByteFloatMap.remove(byte, float) instead
ByteIntMap.remove(byte) instead
ByteIntMap.remove(byte, int) instead
ByteLongMap.remove(byte) instead
ByteLongMap.remove(byte, long) instead
ByteObjMap.remove(byte) instead
ByteObjMap.remove(byte, Object) instead
ByteShortMap.remove(byte) instead
ByteShortMap.remove(byte, short) instead
CharByteMap.remove(char) instead
CharByteMap.remove(char, byte) instead
CharCharMap.remove(char) instead
CharCharMap.remove(char, char) instead
CharDoubleMap.remove(char) instead
CharDoubleMap.remove(char, double) instead
CharFloatMap.remove(char) instead
CharFloatMap.remove(char, float) instead
CharIntMap.remove(char) instead
CharIntMap.remove(char, int) instead
CharLongMap.remove(char) instead
CharLongMap.remove(char, long) instead
CharObjMap.remove(char) instead
CharObjMap.remove(char, Object) instead
CharShortMap.remove(char) instead
CharShortMap.remove(char, short) instead
DoubleByteMap.remove(double) instead
DoubleByteMap.remove(double, byte) instead
DoubleCharMap.remove(double) instead
DoubleCharMap.remove(double, char) instead
DoubleDoubleMap.remove(double) instead
DoubleDoubleMap.remove(double, double) instead
DoubleFloatMap.remove(double) instead
DoubleFloatMap.remove(double, float) instead
DoubleIntMap.remove(double) instead
DoubleIntMap.remove(double, int) instead
DoubleLongMap.remove(double) instead
DoubleLongMap.remove(double, long) instead
DoubleObjMap.remove(double) instead
DoubleObjMap.remove(double, Object) instead
DoubleShortMap.remove(double) instead
DoubleShortMap.remove(double, short) instead
FloatByteMap.remove(float) instead
FloatByteMap.remove(float, byte) instead
FloatCharMap.remove(float) instead
FloatCharMap.remove(float, char) instead
FloatDoubleMap.remove(float) instead
FloatDoubleMap.remove(float, double) instead
FloatFloatMap.remove(float) instead
FloatFloatMap.remove(float, float) instead
FloatIntMap.remove(float) instead
FloatIntMap.remove(float, int) instead
FloatLongMap.remove(float) instead
FloatLongMap.remove(float, long) instead
FloatObjMap.remove(float) instead
FloatObjMap.remove(float, Object) instead
FloatShortMap.remove(float) instead
FloatShortMap.remove(float, short) instead
IntByteMap.remove(int) instead
IntByteMap.remove(int, byte) instead
IntCharMap.remove(int) instead
IntCharMap.remove(int, char) instead
IntDoubleMap.remove(int) instead
IntDoubleMap.remove(int, double) instead
IntFloatMap.remove(int) instead
IntFloatMap.remove(int, float) instead
IntIntMap.remove(int) instead
IntIntMap.remove(int, int) instead
IntLongMap.remove(int) instead
IntLongMap.remove(int, long) instead
IntObjMap.remove(int) instead
IntObjMap.remove(int, Object) instead
IntShortMap.remove(int) instead
IntShortMap.remove(int, short) instead
LongByteMap.remove(long) instead
LongByteMap.remove(long, byte) instead
LongCharMap.remove(long) instead
LongCharMap.remove(long, char) instead
LongDoubleMap.remove(long) instead
LongDoubleMap.remove(long, double) instead
LongFloatMap.remove(long) instead
LongFloatMap.remove(long, float) instead
LongIntMap.remove(long) instead
LongIntMap.remove(long, int) instead
LongLongMap.remove(long) instead
LongLongMap.remove(long, long) instead
LongObjMap.remove(long) instead
LongObjMap.remove(long, Object) instead
LongShortMap.remove(long) instead
LongShortMap.remove(long, short) instead
ObjByteMap.removeAsByte(Object) instead
ObjByteMap.remove(Object, byte) instead
ObjCharMap.removeAsChar(Object) instead
ObjCharMap.remove(Object, char) instead
ObjDoubleMap.removeAsDouble(Object) instead
ObjDoubleMap.remove(Object, double) instead
ObjFloatMap.removeAsFloat(Object) instead
ObjFloatMap.remove(Object, float) instead
ObjIntMap.removeAsInt(Object) instead
ObjIntMap.remove(Object, int) instead
ObjLongMap.removeAsLong(Object) instead
ObjLongMap.remove(Object, long) instead
ObjShortMap.removeAsShort(Object) instead
ObjShortMap.remove(Object, short) instead
ShortByteMap.remove(short) instead
ShortByteMap.remove(short, byte) instead
ShortCharMap.remove(short) instead
ShortCharMap.remove(short, char) instead
ShortDoubleMap.remove(short) instead
ShortDoubleMap.remove(short, double) instead
ShortFloatMap.remove(short) instead
ShortFloatMap.remove(short, float) instead
ShortIntMap.remove(short) instead
ShortIntMap.remove(short, int) instead
ShortLongMap.remove(short) instead
ShortLongMap.remove(short, long) instead
ShortObjMap.remove(short) instead
ShortObjMap.remove(short, Object) instead
ShortShortMap.remove(short) instead
ShortShortMap.remove(short, short) instead
ShortCollection.removeShort(short) instead
ByteCollection.removeIf(BytePredicate) instead
CharCollection.removeIf(CharPredicate) instead
DoubleCollection.removeIf(DoublePredicate) instead
FloatCollection.removeIf(FloatPredicate) instead
IntCollection.removeIf(IntPredicate) instead
LongCollection.removeIf(LongPredicate) instead
ShortCollection.removeIf(ShortPredicate) instead
ByteByteMap.replace(byte, byte) instead
ByteByteMap.replace(byte, byte, byte) instead
ByteCharMap.replace(byte, char) instead
ByteCharMap.replace(byte, char, char) instead
ByteDoubleMap.replace(byte, double) instead
ByteDoubleMap.replace(byte, double, double) instead
ByteFloatMap.replace(byte, float) instead
ByteFloatMap.replace(byte, float, float) instead
ByteIntMap.replace(byte, int) instead
ByteIntMap.replace(byte, int, int) instead
ByteLongMap.replace(byte, long) instead
ByteLongMap.replace(byte, long, long) instead
ByteObjMap.replace(byte, Object) instead
ByteObjMap.replace(byte, Object, Object) instead
ByteShortMap.replace(byte, short) instead
ByteShortMap.replace(byte, short, short) instead
CharByteMap.replace(char, byte) instead
CharByteMap.replace(char, byte, byte) instead
CharCharMap.replace(char, char) instead
CharCharMap.replace(char, char, char) instead
CharDoubleMap.replace(char, double) instead
CharDoubleMap.replace(char, double, double) instead
CharFloatMap.replace(char, float) instead
CharFloatMap.replace(char, float, float) instead
CharIntMap.replace(char, int) instead
CharIntMap.replace(char, int, int) instead
CharLongMap.replace(char, long) instead
CharLongMap.replace(char, long, long) instead
CharObjMap.replace(char, Object) instead
CharObjMap.replace(char, Object, Object) instead
CharShortMap.replace(char, short) instead
CharShortMap.replace(char, short, short) instead
DoubleByteMap.replace(double, byte) instead
DoubleByteMap.replace(double, byte, byte) instead
DoubleCharMap.replace(double, char) instead
DoubleCharMap.replace(double, char, char) instead
DoubleDoubleMap.replace(double, double) instead
DoubleDoubleMap.replace(double, double, double) instead
DoubleFloatMap.replace(double, float) instead
DoubleFloatMap.replace(double, float, float) instead
DoubleIntMap.replace(double, int) instead
DoubleIntMap.replace(double, int, int) instead
DoubleLongMap.replace(double, long) instead
DoubleLongMap.replace(double, long, long) instead
DoubleObjMap.replace(double, Object) instead
DoubleObjMap.replace(double, Object, Object) instead
DoubleShortMap.replace(double, short) instead
DoubleShortMap.replace(double, short, short) instead
FloatByteMap.replace(float, byte) instead
FloatByteMap.replace(float, byte, byte) instead
FloatCharMap.replace(float, char) instead
FloatCharMap.replace(float, char, char) instead
FloatDoubleMap.replace(float, double) instead
FloatDoubleMap.replace(float, double, double) instead
FloatFloatMap.replace(float, float) instead
FloatFloatMap.replace(float, float, float) instead
FloatIntMap.replace(float, int) instead
FloatIntMap.replace(float, int, int) instead
FloatLongMap.replace(float, long) instead
FloatLongMap.replace(float, long, long) instead
FloatObjMap.replace(float, Object) instead
FloatObjMap.replace(float, Object, Object) instead
FloatShortMap.replace(float, short) instead
FloatShortMap.replace(float, short, short) instead
IntByteMap.replace(int, byte) instead
IntByteMap.replace(int, byte, byte) instead
IntCharMap.replace(int, char) instead
IntCharMap.replace(int, char, char) instead
IntDoubleMap.replace(int, double) instead
IntDoubleMap.replace(int, double, double) instead
IntFloatMap.replace(int, float) instead
IntFloatMap.replace(int, float, float) instead
IntIntMap.replace(int, int) instead
IntIntMap.replace(int, int, int) instead
IntLongMap.replace(int, long) instead
IntLongMap.replace(int, long, long) instead
IntObjMap.replace(int, Object) instead
IntObjMap.replace(int, Object, Object) instead
IntShortMap.replace(int, short) instead
IntShortMap.replace(int, short, short) instead
LongByteMap.replace(long, byte) instead
LongByteMap.replace(long, byte, byte) instead
LongCharMap.replace(long, char) instead
LongCharMap.replace(long, char, char) instead
LongDoubleMap.replace(long, double) instead
LongDoubleMap.replace(long, double, double) instead
LongFloatMap.replace(long, float) instead
LongFloatMap.replace(long, float, float) instead
LongIntMap.replace(long, int) instead
LongIntMap.replace(long, int, int) instead
LongLongMap.replace(long, long) instead
LongLongMap.replace(long, long, long) instead
LongObjMap.replace(long, Object) instead
LongObjMap.replace(long, Object, Object) instead
LongShortMap.replace(long, short) instead
LongShortMap.replace(long, short, short) instead
ObjByteMap.replace(Object, byte) instead
ObjByteMap.replace(Object, byte, byte) instead
ObjCharMap.replace(Object, char) instead
ObjCharMap.replace(Object, char, char) instead
ObjDoubleMap.replace(Object, double) instead
ObjDoubleMap.replace(Object, double, double) instead
ObjFloatMap.replace(Object, float) instead
ObjFloatMap.replace(Object, float, float) instead
ObjIntMap.replace(Object, int) instead
ObjIntMap.replace(Object, int, int) instead
ObjLongMap.replace(Object, long) instead
ObjLongMap.replace(Object, long, long) instead
ObjShortMap.replace(Object, short) instead
ObjShortMap.replace(Object, short, short) instead
ShortByteMap.replace(short, byte) instead
ShortByteMap.replace(short, byte, byte) instead
ShortCharMap.replace(short, char) instead
ShortCharMap.replace(short, char, char) instead
ShortDoubleMap.replace(short, double) instead
ShortDoubleMap.replace(short, double, double) instead
ShortFloatMap.replace(short, float) instead
ShortFloatMap.replace(short, float, float) instead
ShortIntMap.replace(short, int) instead
ShortIntMap.replace(short, int, int) instead
ShortLongMap.replace(short, long) instead
ShortLongMap.replace(short, long, long) instead
ShortObjMap.replace(short, Object) instead
ShortObjMap.replace(short, Object, Object) instead
ShortShortMap.replace(short, short) instead
ShortShortMap.replace(short, short, short) instead
ByteByteMap.replaceAll(ByteByteToByteFunction) instead
ByteCharMap.replaceAll(ByteCharToCharFunction) instead
ByteDoubleMap.replaceAll(ByteDoubleToDoubleFunction) instead
ByteFloatMap.replaceAll(ByteFloatToFloatFunction) instead
ByteIntMap.replaceAll(ByteIntToIntFunction) instead
ByteLongMap.replaceAll(ByteLongToLongFunction) instead
ByteObjMap.replaceAll(ByteObjFunction) instead
ByteShortMap.replaceAll(ByteShortToShortFunction) instead
CharByteMap.replaceAll(CharByteToByteFunction) instead
CharCharMap.replaceAll(CharCharToCharFunction) instead
CharDoubleMap.replaceAll(CharDoubleToDoubleFunction) instead
CharFloatMap.replaceAll(CharFloatToFloatFunction) instead
CharIntMap.replaceAll(CharIntToIntFunction) instead
CharLongMap.replaceAll(CharLongToLongFunction) instead
CharObjMap.replaceAll(CharObjFunction) instead
CharShortMap.replaceAll(CharShortToShortFunction) instead
DoubleByteMap.replaceAll(DoubleByteToByteFunction) instead
DoubleCharMap.replaceAll(DoubleCharToCharFunction) instead
DoubleDoubleMap.replaceAll(DoubleDoubleToDoubleFunction) instead
DoubleFloatMap.replaceAll(DoubleFloatToFloatFunction) instead
DoubleIntMap.replaceAll(DoubleIntToIntFunction) instead
DoubleLongMap.replaceAll(DoubleLongToLongFunction) instead
DoubleObjMap.replaceAll(DoubleObjFunction) instead
DoubleShortMap.replaceAll(DoubleShortToShortFunction) instead
FloatByteMap.replaceAll(FloatByteToByteFunction) instead
FloatCharMap.replaceAll(FloatCharToCharFunction) instead
FloatDoubleMap.replaceAll(FloatDoubleToDoubleFunction) instead
FloatFloatMap.replaceAll(FloatFloatToFloatFunction) instead
FloatIntMap.replaceAll(FloatIntToIntFunction) instead
FloatLongMap.replaceAll(FloatLongToLongFunction) instead
FloatObjMap.replaceAll(FloatObjFunction) instead
FloatShortMap.replaceAll(FloatShortToShortFunction) instead
IntByteMap.replaceAll(IntByteToByteFunction) instead
IntCharMap.replaceAll(IntCharToCharFunction) instead
IntDoubleMap.replaceAll(IntDoubleToDoubleFunction) instead
IntFloatMap.replaceAll(IntFloatToFloatFunction) instead
IntIntMap.replaceAll(IntIntToIntFunction) instead
IntLongMap.replaceAll(IntLongToLongFunction) instead
IntObjMap.replaceAll(IntObjFunction) instead
IntShortMap.replaceAll(IntShortToShortFunction) instead
LongByteMap.replaceAll(LongByteToByteFunction) instead
LongCharMap.replaceAll(LongCharToCharFunction) instead
LongDoubleMap.replaceAll(LongDoubleToDoubleFunction) instead
LongFloatMap.replaceAll(LongFloatToFloatFunction) instead
LongIntMap.replaceAll(LongIntToIntFunction) instead
LongLongMap.replaceAll(LongLongToLongFunction) instead
LongObjMap.replaceAll(LongObjFunction) instead
LongShortMap.replaceAll(LongShortToShortFunction) instead
ObjByteMap.replaceAll(ObjByteToByteFunction) instead
ObjCharMap.replaceAll(ObjCharToCharFunction) instead
ObjDoubleMap.replaceAll(ObjDoubleToDoubleFunction) instead
ObjFloatMap.replaceAll(ObjFloatToFloatFunction) instead
ObjIntMap.replaceAll(ObjIntToIntFunction) instead
ObjLongMap.replaceAll(ObjLongToLongFunction) instead
ObjShortMap.replaceAll(ObjShortToShortFunction) instead
ShortByteMap.replaceAll(ShortByteToByteFunction) instead
ShortCharMap.replaceAll(ShortCharToCharFunction) instead
ShortDoubleMap.replaceAll(ShortDoubleToDoubleFunction) instead
ShortFloatMap.replaceAll(ShortFloatToFloatFunction) instead
ShortIntMap.replaceAll(ShortIntToIntFunction) instead
ShortLongMap.replaceAll(ShortLongToLongFunction) instead
ShortObjMap.replaceAll(ShortObjFunction) instead
ShortShortMap.replaceAll(ShortShortToShortFunction) instead
Object keys and
short values.Map specialization with short keys
and byte values.Object keys and
short values.Map specialization with short keys
and char values.shorts.Object keys and
short values.Map specialization with short keys
and double values.Object keys and
short values.Map specialization with short keys
and float values.Object keys and
short values.Map specialization with short keys
and int values.Object keys and
short values.Map specialization with short keys
and long values.Object keys and
short values.Map specialization with short keys
and Object values.Object keys and
short values.Map specialization with short keys
and short values.true,
returns false if the capacity is already minimum needed to hold the current
number of elements.
HashContainer.currentLoad() is less than
HashContainer.hashConfig().
Equivalence implementations.ByteCollection.toByteArray() instead
ByteCollection.toArray(byte[]) instead
CharCollection.toCharArray() instead
CharCollection.toArray(char[]) instead
DoubleCollection.toDoubleArray() instead
DoubleCollection.toArray(double[]) instead
FloatCollection.toFloatArray() instead
FloatCollection.toArray(float[]) instead
IntCollection.toIntArray() instead
IntCollection.toArray(int[]) instead
LongCollection.toLongArray() instead
LongCollection.toArray(long[]) instead
ShortCollection.toShortArray() instead
ShortCollection.toArray(short[]) instead
|
|||||||||
| PREV NEXT | FRAMES NO FRAMES | ||||||||